# uncompyle6 version 3.2.3
# Python bytecode 3.6 (3379)
# Decompiled from: Python 3.6.8 |Anaconda custom (64-bit)| (default, Feb 21 2019, 18:30:04) [MSC v.1916 64 bit (AMD64)]
# Embedded file name: site-packages\sqlalchemy\dialects\mysql\enumerated.py
import re
from .types import _StringType
from ... import exc, sql, util
from ...sql import sqltypes


class _EnumeratedValues(_StringType):
    def _init_values(self, values, kw):
        self.quoting = kw.pop("quoting", "auto")
        if self.quoting == "auto":
            if len(values):
                q = None
                for e in values:
                    if len(e) == 0:
                        self.quoting = "unquoted"
                        break
                    else:
                        if q is None:
                            q = e[0]
                    if len(e) == 1 or e[0] != q or e[-1] != q:
                        self.quoting = "unquoted"
                        break
                else:
                    self.quoting = "quoted"

        if self.quoting == "quoted":
            util.warn_deprecated(
                "Manually quoting %s value literals is deprecated.  Supply unquoted values and use the quoting= option in cases of ambiguity."
                % self.__class__.__name__
            )
            values = self._strip_values(values)
        self._enumerated_values = values
        length = max([len(v) for v in values] + [0])
        return (values, length)

    @classmethod
    def _strip_values(cls, values):
        strip_values = []
        for a in values:
            if a[0:1] == '"' or a[0:1] == "'":
                a = a[1:-1].replace(a[0] * 2, a[0])
            strip_values.append(a)

        return strip_values


class ENUM(sqltypes.NativeForEmulated, sqltypes.Enum, _EnumeratedValues):
    """MySQL ENUM type."""

    __visit_name__ = "ENUM"
    native_enum = True

    def __init__(self, *enums, **kw):
        """Construct an ENUM.
        
        E.g.::
        
          Column('myenum', ENUM("foo", "bar", "baz"))
        
        :param enums: The range of valid values for this ENUM.  Values will be
          quoted when generating the schema according to the quoting flag (see
          below).  This object may also be a PEP-435-compliant enumerated
          type.
        
          .. versionadded: 1.1 added support for PEP-435-compliant enumerated
             types.
        
        :param strict: This flag has no effect.
        
         .. versionchanged:: The MySQL ENUM type as well as the base Enum
            type now validates all Python data values.
        
        :param charset: Optional, a column-level character set for this string
          value.  Takes precedence to 'ascii' or 'unicode' short-hand.
        
        :param collation: Optional, a column-level collation for this string
          value.  Takes precedence to 'binary' short-hand.
        
        :param ascii: Defaults to False: short-hand for the ``latin1``
          character set, generates ASCII in schema.
        
        :param unicode: Defaults to False: short-hand for the ``ucs2``
          character set, generates UNICODE in schema.
        
        :param binary: Defaults to False: short-hand, pick the binary
          collation type that matches the column's character set.  Generates
          BINARY in schema.  This does not affect the type of data stored,
          only the collation of character data.
        
        :param quoting: Defaults to 'auto': automatically determine enum value
          quoting.  If all enum values are surrounded by the same quoting
          character, then use 'quoted' mode.  Otherwise, use 'unquoted' mode.
        
          'quoted': values in enums are already quoted, they will be used
          directly when generating the schema - this usage is deprecated.
        
          'unquoted': values in enums are not quoted, they will be escaped and
          surrounded by single quotes when generating the schema.
        
          Previous versions of this type always required manually quoted
          values to be supplied; future versions will always quote the string
          literals for you.  This is a transitional option.
        
        """
        kw.pop("strict", None)
        self._enum_init(enums, kw)
        _StringType.__init__(length=self.length, **kw)

    @classmethod
    def adapt_emulated_to_native(cls, impl, **kw):
        """Produce a MySQL native :class:`.mysql.ENUM` from plain
        :class:`.Enum`.
        
        """
        kw.setdefault("validate_strings", impl.validate_strings)
        return cls(**kw)

    def _setup_for_values(self, values, objects, kw):
        values, length = self._init_values(values, kw)
        return super(ENUM, self)._setup_for_values(values, objects, kw)

    def _object_value_for_elem(self, elem):
        if elem == "":
            return elem
        else:
            return super(ENUM, self)._object_value_for_elem(elem)

    def __repr__(self):
        return util.generic_repr(self, to_inspect=[ENUM, _StringType, sqltypes.Enum])


class SET(_EnumeratedValues):
    """MySQL SET type."""

    __visit_name__ = "SET"

    def __init__(self, *values, **kw):
        """Construct a SET.
        
        E.g.::
        
          Column('myset', SET("foo", "bar", "baz"))
        
        
        The list of potential values is required in the case that this
        set will be used to generate DDL for a table, or if the
        :paramref:`.SET.retrieve_as_bitwise` flag is set to True.
        
        :param values: The range of valid values for this SET.
        
        :param convert_unicode: Same flag as that of
         :paramref:`.String.convert_unicode`.
        
        :param collation: same as that of :paramref:`.String.collation`
        
        :param charset: same as that of :paramref:`.VARCHAR.charset`.
        
        :param ascii: same as that of :paramref:`.VARCHAR.ascii`.
        
        :param unicode: same as that of :paramref:`.VARCHAR.unicode`.
        
        :param binary: same as that of :paramref:`.VARCHAR.binary`.
        
        :param quoting: Defaults to 'auto': automatically determine set value
          quoting.  If all values are surrounded by the same quoting
          character, then use 'quoted' mode.  Otherwise, use 'unquoted' mode.
        
          'quoted': values in enums are already quoted, they will be used
          directly when generating the schema - this usage is deprecated.
        
          'unquoted': values in enums are not quoted, they will be escaped and
          surrounded by single quotes when generating the schema.
        
          Previous versions of this type always required manually quoted
          values to be supplied; future versions will always quote the string
          literals for you.  This is a transitional option.
        
          .. versionadded:: 0.9.0
        
        :param retrieve_as_bitwise: if True, the data for the set type will be
          persisted and selected using an integer value, where a set is coerced
          into a bitwise mask for persistence.  MySQL allows this mode which
          has the advantage of being able to store values unambiguously,
          such as the blank string ``''``.   The datatype will appear
          as the expression ``col + 0`` in a SELECT statement, so that the
          value is coerced into an integer value in result sets.
          This flag is required if one wishes
          to persist a set that can store the blank string ``''`` as a value.
        
          .. warning::
        
            When using :paramref:`.mysql.SET.retrieve_as_bitwise`, it is
            essential that the list of set values is expressed in the
            **exact same order** as exists on the MySQL database.
        
          .. versionadded:: 1.0.0
        
        
        """
        self.retrieve_as_bitwise = kw.pop("retrieve_as_bitwise", False)
        values, length = self._init_values(values, kw)
        self.values = tuple(values)
        if not self.retrieve_as_bitwise:
            if "" in values:
                raise exc.ArgumentError(
                    "Can't use the blank value '' in a SET without setting retrieve_as_bitwise=True"
                )
        if self.retrieve_as_bitwise:
            self._bitmap = dict(
                ((value, 2 ** idx) for idx, value in enumerate(self.values))
            )
            self._bitmap.update(
                ((2 ** idx, value) for idx, value in enumerate(self.values))
            )
        kw.setdefault("length", length)
        super(SET, self).__init__(**kw)

    def column_expression(self, colexpr):
        if self.retrieve_as_bitwise:
            return sql.type_coerce(sql.type_coerce(colexpr, sqltypes.Integer) + 0, self)
        else:
            return colexpr

    def result_processor(self, dialect, coltype):
        if self.retrieve_as_bitwise:

            def process(value):
                if value is not None:
                    value = int(value)
                    return set(util.map_bits(self._bitmap.__getitem__, value))
                else:
                    return

        else:
            super_convert = super(SET, self).result_processor(dialect, coltype)

            def process(value):
                if isinstance(value, util.string_types):
                    if super_convert:
                        value = super_convert(value)
                    return set(re.findall("[^,]+", value))
                else:
                    if value is not None:
                        value.discard("")
                    return value

        return process

    def bind_processor(self, dialect):
        super_convert = super(SET, self).bind_processor(dialect)
        if self.retrieve_as_bitwise:

            def process(value):
                if value is None:
                    return
                if isinstance(value, util.int_types + util.string_types):
                    if super_convert:
                        return super_convert(value)
                    return value
                else:
                    int_value = 0
                    for v in value:
                        int_value |= self._bitmap[v]

                    return int_value

        else:

            def process(value):
                if value is not None:
                    if not isinstance(value, util.int_types + util.string_types):
                        value = (",").join(value)
                if super_convert:
                    return super_convert(value)
                else:
                    return value

        return process

    def adapt(self, impltype, **kw):
        kw["retrieve_as_bitwise"] = self.retrieve_as_bitwise
        return util.constructor_copy(self, impltype, *self.values, **kw)
